using System;
using System.Reflection;
using System.Runtime.InteropServices;
using Kitware.mummy.Runtime;

namespace Kitware.VTK;

/// <summary>
///    vtkGL2PSExporter
/// </summary>
/// <remarks>
///    export a scene as a PostScript file using GL2PS.
///
/// vtkGL2PSExporter is a concrete subclass of vtkExporter that writes
/// high quality vector PostScript (PS/EPS), PDF or SVG files by using
/// GL2PS.  GL2PS can be obtained at: http://www.geuz.org/gl2ps/.  This
/// can be very useful when one requires publication quality pictures.
/// This class works best with simple 3D scenes and most 2D plots.
/// Please note that GL2PS has its limitations since PostScript is not
/// an ideal language to represent complex 3D scenes.  However, this
/// class does allow one to write mixed vector/raster files by using
/// the Write3DPropsAsRasterImage ivar.  Please do read the caveats
/// section of this documentation.
///
/// By default vtkGL2PSExporter generates Encapsulated PostScript (EPS)
/// output along with the text in portrait orientation with the
/// background color of the window being drawn.  The generated output
/// is also compressed using zlib. The various other options are set to
/// sensible defaults.
///
/// The output file format (FileFormat) can be either PostScript (PS),
/// Encapsulated PostScript (EPS), PDF, SVG or TeX.  The file extension
/// is generated automatically depending on the FileFormat.  The
/// default is EPS.  When TeX output is chosen, only the text strings
/// in the plot are generated and put into a picture environment.  One
/// can turn on and off the text when generating PS/EPS/PDF/SVG files
/// by using the Text boolean variable.  By default the text is drawn.
/// The background color of the renderwindow is drawn by default.  To
/// make the background white instead use the DrawBackgroundOff
/// function.  Landscape figures can be generated by using the
/// LandscapeOn function.  Portrait orientation is used by default.
/// Several of the GL2PS options can be set.  The names of the ivars
/// for these options are similar to the ones that GL2PS provides.
/// Compress, SimpleLineOffset, Silent, BestRoot, PS3Shading and
/// OcclusionCull are similar to the options provided by GL2PS.  Please
/// read the function documentation or the GL2PS documentation for more
/// details.  The ivar Write3DPropsAsRasterImage allows one to generate
/// mixed vector/raster images.  All the 3D props in the scene will be
/// written as a raster image and all 2D actors will be written as
/// vector graphic primitives.  This makes it possible to handle
/// transparency and complex 3D scenes.  This ivar is set to Off by
/// default.  Specific 3D props can be excluded from the rasterization
/// process by adding them to the RasterExclusions ivar.  Props in this
/// collection will be rendered as 2D vector primitives instead.
///
/// @warning
/// By default (with Write3DPropsAsRasterImage set to Off) exporting
/// complex 3D scenes can take a long while and result in huge output
/// files.  Generating correct vector graphics output for scenes with
/// transparency is almost impossible.  However, one can set
/// Write3DPropsAsRasterImageOn and generate mixed vector/raster files.
/// This should work fine with complex scenes along with transparent
/// actors.
///
/// </remarks>
/// <seealso>
///
/// vtkExporter
///
/// @par Thanks:
/// Thanks to Goodwin Lawlor and Prabhu Ramachandran for this class.
/// </seealso>
public abstract class vtkGL2PSExporter : vtkExporter
{
	/// <summary>
	/// Set the title for the output, if supported. If nullptr, "VTK GL2PS Export" is
	/// used.
	/// </summary>
	public enum OutputFormat
	{
		/// <summary>enum member</summary>
		EPS_FILE = 1,
		/// <summary>enum member</summary>
		PDF_FILE = 2,
		/// <summary>enum member</summary>
		PS_FILE = 0,
		/// <summary>enum member</summary>
		SVG_FILE = 4,
		/// <summary>enum member</summary>
		TEX_FILE = 3
	}

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public enum SortScheme
	{
		/// <summary>enum member</summary>
		BSP_SORT = 2,
		/// <summary>enum member</summary>
		NO_SORT = 0,
		/// <summary>enum member</summary>
		SIMPLE_SORT = 1
	}

	/// <summary>
	/// Automatically generated type registration mechanics.
	/// </summary>
	public new const string MRFullTypeName = "Kitware.VTK.vtkGL2PSExporter";

	/// <summary>
	/// Automatically generated type registration mechanics.
	/// </summary>
	public new static readonly string MRClassNameKey;

	/// <summary>
	/// Automatically generated type registration mechanics.
	/// </summary>
	static vtkGL2PSExporter()
	{
		MRClassNameKey = "class vtkGL2PSExporter";
		Methods.RegisterType(Assembly.GetExecutingAssembly(), MRClassNameKey, Type.GetType("Kitware.VTK.vtkGL2PSExporter"));
	}

	/// <summary>
	/// Automatically generated constructor - called from generated code.
	/// DO NOT call directly.
	/// </summary>
	public vtkGL2PSExporter(IntPtr rawCppThis, bool callDisposalMethod, bool strong)
		: base(rawCppThis, callDisposalMethod, strong)
	{
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_New(ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public new static vtkGL2PSExporter New()
	{
		vtkGL2PSExporter result = null;
		uint mteStatus = 0u;
		uint mteIndex = uint.MaxValue;
		uint rawRefCount = 0u;
		IntPtr intPtr = vtkGL2PSExporter_New(ref mteStatus, ref mteIndex, ref rawRefCount);
		if (IntPtr.Zero != intPtr)
		{
			result = (vtkGL2PSExporter)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, callDisposalMethod: true, out var _);
		}
		return result;
	}

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public vtkGL2PSExporter()
		: base(IntPtr.Zero, callDisposalMethod: false, strong: false)
	{
		uint mteStatus = 0u;
		uint mteIndex = uint.MaxValue;
		uint rawRefCount = 0u;
		IntPtr rawCppThis = vtkGL2PSExporter_New(ref mteStatus, ref mteIndex, ref rawRefCount);
		SetCppThis(rawCppThis, callDisposalMethod: true, (mteStatus != 0 && rawRefCount >= 2) ? true : false);
	}

	/// <summary>
	/// Automatically generated protected Dispose method - called from
	/// public Dispose or the C# destructor. DO NOT call directly.
	/// </summary>
	protected override void Dispose(bool disposing)
	{
		base.Dispose(disposing);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_BestRootOff_01(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_BEST_ROOT option.  When enabled the
	/// construction of the BSP tree is optimized by choosing the root
	/// primitives leading to the minimum number of splits.  Defaults to
	/// on.
	/// </summary>
	public virtual void BestRootOff()
	{
		vtkGL2PSExporter_BestRootOff_01(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_BestRootOn_02(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_BEST_ROOT option.  When enabled the
	/// construction of the BSP tree is optimized by choosing the root
	/// primitives leading to the minimum number of splits.  Defaults to
	/// on.
	/// </summary>
	public virtual void BestRootOn()
	{
		vtkGL2PSExporter_BestRootOn_02(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_CompressOff_03(HandleRef pThis);

	/// <summary>
	/// Turn on/off compression when generating PostScript or PDF
	/// output. By default compression is on.
	/// </summary>
	public virtual void CompressOff()
	{
		vtkGL2PSExporter_CompressOff_03(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_CompressOn_04(HandleRef pThis);

	/// <summary>
	/// Turn on/off compression when generating PostScript or PDF
	/// output. By default compression is on.
	/// </summary>
	public virtual void CompressOn()
	{
		vtkGL2PSExporter_CompressOn_04(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_DrawBackgroundOff_05(HandleRef pThis);

	/// <summary>
	/// Turn on/off drawing the background frame.  If off the background
	/// is treated as white.  By default the background is drawn.
	/// On the OpenGL2 backend, the background is always drawn.
	/// </summary>
	public virtual void DrawBackgroundOff()
	{
		vtkGL2PSExporter_DrawBackgroundOff_05(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_DrawBackgroundOn_06(HandleRef pThis);

	/// <summary>
	/// Turn on/off drawing the background frame.  If off the background
	/// is treated as white.  By default the background is drawn.
	/// On the OpenGL2 backend, the background is always drawn.
	/// </summary>
	public virtual void DrawBackgroundOn()
	{
		vtkGL2PSExporter_DrawBackgroundOn_06(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetBestRoot_07(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_BEST_ROOT option.  When enabled the
	/// construction of the BSP tree is optimized by choosing the root
	/// primitives leading to the minimum number of splits.  Defaults to
	/// on.
	/// </summary>
	public virtual int GetBestRoot()
	{
		return vtkGL2PSExporter_GetBestRoot_07(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetBufferSize_08(HandleRef pThis);

	/// <summary>
	/// The initial size of the GL2PS export buffer in bytes. The buffer is used to
	/// store the exported image prior to writing to file. If the buffer is too
	/// small, the exporter will enlarge the buffer and rerender until the export
	/// is successful. Setting a larger value here can reduce the time needed to
	/// export a complex scene by reducing the number of iterations required.
	/// The default initial size is 4 MB.
	/// </summary>
	public virtual int GetBufferSize()
	{
		return vtkGL2PSExporter_GetBufferSize_08(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetCompress_09(HandleRef pThis);

	/// <summary>
	/// Turn on/off compression when generating PostScript or PDF
	/// output. By default compression is on.
	/// </summary>
	public virtual int GetCompress()
	{
		return vtkGL2PSExporter_GetCompress_09(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetDrawBackground_10(HandleRef pThis);

	/// <summary>
	/// Turn on/off drawing the background frame.  If off the background
	/// is treated as white.  By default the background is drawn.
	/// On the OpenGL2 backend, the background is always drawn.
	/// </summary>
	public virtual int GetDrawBackground()
	{
		return vtkGL2PSExporter_GetDrawBackground_10(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetFileFormat_11(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public virtual int GetFileFormat()
	{
		return vtkGL2PSExporter_GetFileFormat_11(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_GetFileFormatAsString_12(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public string GetFileFormatAsString()
	{
		return Marshal.PtrToStringAnsi(vtkGL2PSExporter_GetFileFormatAsString_12(GetCppThis()));
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetFileFormatMaxValue_13(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public virtual int GetFileFormatMaxValue()
	{
		return vtkGL2PSExporter_GetFileFormatMaxValue_13(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetFileFormatMinValue_14(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public virtual int GetFileFormatMinValue()
	{
		return vtkGL2PSExporter_GetFileFormatMinValue_14(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_GetFilePrefix_15(HandleRef pThis);

	/// <summary>
	/// Specify the prefix of the files to write out. The resulting filenames
	/// will have .ps or .eps or .tex appended to them depending on the
	/// other options chosen.
	/// </summary>
	public virtual string GetFilePrefix()
	{
		return Marshal.PtrToStringAnsi(vtkGL2PSExporter_GetFilePrefix_15(GetCppThis()));
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetLandscape_16(HandleRef pThis);

	/// <summary>
	/// Turn on/off landscape orientation.  If off (default) the
	/// orientation is set to portrait.
	/// </summary>
	public virtual int GetLandscape()
	{
		return vtkGL2PSExporter_GetLandscape_16(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern float vtkGL2PSExporter_GetLineWidthFactor_17(HandleRef pThis);

	/// <summary>
	/// Set the ratio between the OpenGL LineWidth and that used by GL2PS
	/// to generate PostScript.  Defaults to a ratio of 5/7.
	/// </summary>
	public virtual float GetLineWidthFactor()
	{
		return vtkGL2PSExporter_GetLineWidthFactor_17(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern long vtkGL2PSExporter_GetNumberOfGenerationsFromBase_18(HandleRef pThis, string type);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public override long GetNumberOfGenerationsFromBase(string type)
	{
		return vtkGL2PSExporter_GetNumberOfGenerationsFromBase_18(GetCppThis(), type);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern long vtkGL2PSExporter_GetNumberOfGenerationsFromBaseType_19(string type);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public new static long GetNumberOfGenerationsFromBaseType(string type)
	{
		return vtkGL2PSExporter_GetNumberOfGenerationsFromBaseType_19(type);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetOcclusionCull_20(HandleRef pThis);

	/// <summary>
	/// Turn on/off culling of occluded polygons (GL2PS_OCCLUSION_CULL).
	/// When enabled hidden polygons are removed.  This reduces file size
	/// considerably.  Defaults to on.
	/// </summary>
	public virtual int GetOcclusionCull()
	{
		return vtkGL2PSExporter_GetOcclusionCull_20(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetPS3Shading_21(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_PS3_SHADING option.  When enabled the
	/// shfill PostScript level 3 operator is used.  Read the GL2PS
	/// documentation for more details.  Defaults to on.
	/// </summary>
	public virtual int GetPS3Shading()
	{
		return vtkGL2PSExporter_GetPS3Shading_21(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern float vtkGL2PSExporter_GetPointSizeFactor_22(HandleRef pThis);

	/// <summary>
	/// Set the ratio between the OpenGL PointSize and that used by GL2PS
	/// to generate PostScript.  Defaults to a ratio of 5/7.
	/// </summary>
	public virtual float GetPointSizeFactor()
	{
		return vtkGL2PSExporter_GetPointSizeFactor_22(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_GetRasterExclusions_23(HandleRef pThis, ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount);

	/// <summary>
	/// Collection of props to exclude from rasterization. These will be
	/// rendered as 2D vector primitives in the output. This setting is ignored if
	/// Write3DPropsAsRasterImage is false. Behind the scenes, these props are
	/// treated as 2D props during the vector output generation.
	/// </summary>
	public virtual vtkPropCollection GetRasterExclusions()
	{
		vtkPropCollection vtkPropCollection2 = null;
		uint mteStatus = 0u;
		uint mteIndex = uint.MaxValue;
		uint rawRefCount = 0u;
		IntPtr intPtr = vtkGL2PSExporter_GetRasterExclusions_23(GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);
		if (IntPtr.Zero != intPtr)
		{
			vtkPropCollection2 = (vtkPropCollection)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, callDisposalMethod: true, out var found);
			if (found)
			{
				vtkPropCollection2.Register(null);
			}
		}
		return vtkPropCollection2;
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetSilent_24(HandleRef pThis);

	/// <summary>
	/// Turn on/off GL2PS messages sent to stderr (GL2PS_SILENT).  When
	/// enabled GL2PS messages are suppressed.  Defaults to off.
	/// </summary>
	public virtual int GetSilent()
	{
		return vtkGL2PSExporter_GetSilent_24(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetSimpleLineOffset_25(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_SIMPLE_LINE_OFFSET option.  When enabled a
	/// small offset is added in the z-buffer to all the lines in the
	/// plot.  This results in an anti-aliasing like solution.  Defaults to
	/// on.
	/// </summary>
	public virtual int GetSimpleLineOffset()
	{
		return vtkGL2PSExporter_GetSimpleLineOffset_25(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetSort_26(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public virtual int GetSort()
	{
		return vtkGL2PSExporter_GetSort_26(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_GetSortAsString_27(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public string GetSortAsString()
	{
		return Marshal.PtrToStringAnsi(vtkGL2PSExporter_GetSortAsString_27(GetCppThis()));
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetSortMaxValue_28(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public virtual int GetSortMaxValue()
	{
		return vtkGL2PSExporter_GetSortMaxValue_28(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetSortMinValue_29(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public virtual int GetSortMinValue()
	{
		return vtkGL2PSExporter_GetSortMinValue_29(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetText_30(HandleRef pThis);

	/// <summary>
	/// Turn on/off drawing the text.  If on (default) the text is drawn.
	/// If the FileFormat is set to TeX output then a LaTeX picture is
	/// generated with the text strings.  If off text output is
	/// suppressed.
	/// </summary>
	public virtual int GetText()
	{
		return vtkGL2PSExporter_GetText_30(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern byte vtkGL2PSExporter_GetTextAsPath_31(HandleRef pThis);

	/// <summary>
	/// Turn on/off exporting text as path information, rather than character data.
	/// This is useful for the PDF backend, which does not properly
	/// support aligned text otherwise. Defaults to Off.
	/// </summary>
	public virtual bool GetTextAsPath()
	{
		return (vtkGL2PSExporter_GetTextAsPath_31(GetCppThis()) != 0) ? true : false;
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_GetTitle_32(HandleRef pThis);

	/// <summary>
	/// Set the title for the output, if supported. If nullptr, "VTK GL2PS Export" is
	/// used.
	/// </summary>
	public virtual string GetTitle()
	{
		return Marshal.PtrToStringAnsi(vtkGL2PSExporter_GetTitle_32(GetCppThis()));
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_GetWrite3DPropsAsRasterImage_33(HandleRef pThis);

	/// <summary>
	/// Turn on/off writing 3D props as raster images.  2D props are
	/// rendered using vector graphics primitives.  If you have hi-res
	/// actors and are using transparency you probably need to turn this
	/// on.  Defaults to Off.
	/// This option has no effect when the OpenGL2 backend is in use, as all
	/// 3D props (excluding vtkTextActor3D) are rasterized into the background.
	/// </summary>
	public virtual int GetWrite3DPropsAsRasterImage()
	{
		return vtkGL2PSExporter_GetWrite3DPropsAsRasterImage_33(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_IsA_34(HandleRef pThis, string type);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public override int IsA(string type)
	{
		return vtkGL2PSExporter_IsA_34(GetCppThis(), type);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern int vtkGL2PSExporter_IsTypeOf_35(string type);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public new static int IsTypeOf(string type)
	{
		return vtkGL2PSExporter_IsTypeOf_35(type);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_LandscapeOff_36(HandleRef pThis);

	/// <summary>
	/// Turn on/off landscape orientation.  If off (default) the
	/// orientation is set to portrait.
	/// </summary>
	public virtual void LandscapeOff()
	{
		vtkGL2PSExporter_LandscapeOff_36(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_LandscapeOn_37(HandleRef pThis);

	/// <summary>
	/// Turn on/off landscape orientation.  If off (default) the
	/// orientation is set to portrait.
	/// </summary>
	public virtual void LandscapeOn()
	{
		vtkGL2PSExporter_LandscapeOn_37(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_NewInstance_39(HandleRef pThis, ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public new vtkGL2PSExporter NewInstance()
	{
		vtkGL2PSExporter result = null;
		uint mteStatus = 0u;
		uint mteIndex = uint.MaxValue;
		uint rawRefCount = 0u;
		IntPtr intPtr = vtkGL2PSExporter_NewInstance_39(GetCppThis(), ref mteStatus, ref mteIndex, ref rawRefCount);
		if (IntPtr.Zero != intPtr)
		{
			result = (vtkGL2PSExporter)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, callDisposalMethod: true, out var _);
		}
		return result;
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_OcclusionCullOff_40(HandleRef pThis);

	/// <summary>
	/// Turn on/off culling of occluded polygons (GL2PS_OCCLUSION_CULL).
	/// When enabled hidden polygons are removed.  This reduces file size
	/// considerably.  Defaults to on.
	/// </summary>
	public virtual void OcclusionCullOff()
	{
		vtkGL2PSExporter_OcclusionCullOff_40(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_OcclusionCullOn_41(HandleRef pThis);

	/// <summary>
	/// Turn on/off culling of occluded polygons (GL2PS_OCCLUSION_CULL).
	/// When enabled hidden polygons are removed.  This reduces file size
	/// considerably.  Defaults to on.
	/// </summary>
	public virtual void OcclusionCullOn()
	{
		vtkGL2PSExporter_OcclusionCullOn_41(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_PS3ShadingOff_42(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_PS3_SHADING option.  When enabled the
	/// shfill PostScript level 3 operator is used.  Read the GL2PS
	/// documentation for more details.  Defaults to on.
	/// </summary>
	public virtual void PS3ShadingOff()
	{
		vtkGL2PSExporter_PS3ShadingOff_42(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_PS3ShadingOn_43(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_PS3_SHADING option.  When enabled the
	/// shfill PostScript level 3 operator is used.  Read the GL2PS
	/// documentation for more details.  Defaults to on.
	/// </summary>
	public virtual void PS3ShadingOn()
	{
		vtkGL2PSExporter_PS3ShadingOn_43(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern IntPtr vtkGL2PSExporter_SafeDownCast_44(HandleRef o, ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount);

	/// <summary>
	///             Undocumented Block
	/// </summary>
	public new static vtkGL2PSExporter SafeDownCast(vtkObjectBase o)
	{
		vtkGL2PSExporter vtkGL2PSExporter2 = null;
		uint mteStatus = 0u;
		uint mteIndex = uint.MaxValue;
		uint rawRefCount = 0u;
		IntPtr intPtr = vtkGL2PSExporter_SafeDownCast_44(o?.GetCppThis() ?? default(HandleRef), ref mteStatus, ref mteIndex, ref rawRefCount);
		if (IntPtr.Zero != intPtr)
		{
			vtkGL2PSExporter2 = (vtkGL2PSExporter)Methods.CreateWrappedObject(mteStatus, mteIndex, rawRefCount, intPtr, callDisposalMethod: true, out var found);
			if (found)
			{
				vtkGL2PSExporter2.Register(null);
			}
		}
		return vtkGL2PSExporter2;
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetBestRoot_45(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off the GL2PS_BEST_ROOT option.  When enabled the
	/// construction of the BSP tree is optimized by choosing the root
	/// primitives leading to the minimum number of splits.  Defaults to
	/// on.
	/// </summary>
	public virtual void SetBestRoot(int _arg)
	{
		vtkGL2PSExporter_SetBestRoot_45(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetBufferSize_46(HandleRef pThis, int _arg);

	/// <summary>
	/// The initial size of the GL2PS export buffer in bytes. The buffer is used to
	/// store the exported image prior to writing to file. If the buffer is too
	/// small, the exporter will enlarge the buffer and rerender until the export
	/// is successful. Setting a larger value here can reduce the time needed to
	/// export a complex scene by reducing the number of iterations required.
	/// The default initial size is 4 MB.
	/// </summary>
	public virtual void SetBufferSize(int _arg)
	{
		vtkGL2PSExporter_SetBufferSize_46(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetCompress_47(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off compression when generating PostScript or PDF
	/// output. By default compression is on.
	/// </summary>
	public virtual void SetCompress(int _arg)
	{
		vtkGL2PSExporter_SetCompress_47(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetDrawBackground_48(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off drawing the background frame.  If off the background
	/// is treated as white.  By default the background is drawn.
	/// On the OpenGL2 backend, the background is always drawn.
	/// </summary>
	public virtual void SetDrawBackground(int _arg)
	{
		vtkGL2PSExporter_SetDrawBackground_48(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFileFormat_49(HandleRef pThis, int _arg);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public virtual void SetFileFormat(int _arg)
	{
		vtkGL2PSExporter_SetFileFormat_49(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFileFormatToEPS_50(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public void SetFileFormatToEPS()
	{
		vtkGL2PSExporter_SetFileFormatToEPS_50(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFileFormatToPDF_51(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public void SetFileFormatToPDF()
	{
		vtkGL2PSExporter_SetFileFormatToPDF_51(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFileFormatToPS_52(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public void SetFileFormatToPS()
	{
		vtkGL2PSExporter_SetFileFormatToPS_52(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFileFormatToSVG_53(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public void SetFileFormatToSVG()
	{
		vtkGL2PSExporter_SetFileFormatToSVG_53(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFileFormatToTeX_54(HandleRef pThis);

	/// <summary>
	/// Specify the format of file to write out.  This can be one of:
	/// PS_FILE, EPS_FILE, PDF_FILE, TEX_FILE.  Defaults to EPS_FILE.
	/// Depending on the option chosen it generates the appropriate file
	/// (with correct extension) when the Write function is called.
	/// </summary>
	public void SetFileFormatToTeX()
	{
		vtkGL2PSExporter_SetFileFormatToTeX_54(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetFilePrefix_55(HandleRef pThis, string _arg);

	/// <summary>
	/// Specify the prefix of the files to write out. The resulting filenames
	/// will have .ps or .eps or .tex appended to them depending on the
	/// other options chosen.
	/// </summary>
	public virtual void SetFilePrefix(string _arg)
	{
		vtkGL2PSExporter_SetFilePrefix_55(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetLandscape_56(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off landscape orientation.  If off (default) the
	/// orientation is set to portrait.
	/// </summary>
	public virtual void SetLandscape(int _arg)
	{
		vtkGL2PSExporter_SetLandscape_56(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetLineWidthFactor_57(HandleRef pThis, float _arg);

	/// <summary>
	/// Set the ratio between the OpenGL LineWidth and that used by GL2PS
	/// to generate PostScript.  Defaults to a ratio of 5/7.
	/// </summary>
	public virtual void SetLineWidthFactor(float _arg)
	{
		vtkGL2PSExporter_SetLineWidthFactor_57(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetOcclusionCull_58(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off culling of occluded polygons (GL2PS_OCCLUSION_CULL).
	/// When enabled hidden polygons are removed.  This reduces file size
	/// considerably.  Defaults to on.
	/// </summary>
	public virtual void SetOcclusionCull(int _arg)
	{
		vtkGL2PSExporter_SetOcclusionCull_58(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetPS3Shading_59(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off the GL2PS_PS3_SHADING option.  When enabled the
	/// shfill PostScript level 3 operator is used.  Read the GL2PS
	/// documentation for more details.  Defaults to on.
	/// </summary>
	public virtual void SetPS3Shading(int _arg)
	{
		vtkGL2PSExporter_SetPS3Shading_59(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetPointSizeFactor_60(HandleRef pThis, float _arg);

	/// <summary>
	/// Set the ratio between the OpenGL PointSize and that used by GL2PS
	/// to generate PostScript.  Defaults to a ratio of 5/7.
	/// </summary>
	public virtual void SetPointSizeFactor(float _arg)
	{
		vtkGL2PSExporter_SetPointSizeFactor_60(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetRasterExclusions_61(HandleRef pThis, HandleRef arg0);

	/// <summary>
	/// Collection of props to exclude from rasterization. These will be
	/// rendered as 2D vector primitives in the output. This setting is ignored if
	/// Write3DPropsAsRasterImage is false. Behind the scenes, these props are
	/// treated as 2D props during the vector output generation.
	/// </summary>
	public void SetRasterExclusions(vtkPropCollection arg0)
	{
		vtkGL2PSExporter_SetRasterExclusions_61(GetCppThis(), arg0?.GetCppThis() ?? default(HandleRef));
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetSilent_62(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off GL2PS messages sent to stderr (GL2PS_SILENT).  When
	/// enabled GL2PS messages are suppressed.  Defaults to off.
	/// </summary>
	public virtual void SetSilent(int _arg)
	{
		vtkGL2PSExporter_SetSilent_62(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetSimpleLineOffset_63(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off the GL2PS_SIMPLE_LINE_OFFSET option.  When enabled a
	/// small offset is added in the z-buffer to all the lines in the
	/// plot.  This results in an anti-aliasing like solution.  Defaults to
	/// on.
	/// </summary>
	public virtual void SetSimpleLineOffset(int _arg)
	{
		vtkGL2PSExporter_SetSimpleLineOffset_63(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetSort_64(HandleRef pThis, int _arg);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public virtual void SetSort(int _arg)
	{
		vtkGL2PSExporter_SetSort_64(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetSortToBSP_65(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public void SetSortToBSP()
	{
		vtkGL2PSExporter_SetSortToBSP_65(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetSortToOff_66(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public void SetSortToOff()
	{
		vtkGL2PSExporter_SetSortToOff_66(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetSortToSimple_67(HandleRef pThis);

	/// <summary>
	/// Set the type of sorting algorithm to order primitives from
	/// back to front.  Successive algorithms are more memory
	/// intensive.  Simple is the default but BSP is perhaps the best.
	/// </summary>
	public void SetSortToSimple()
	{
		vtkGL2PSExporter_SetSortToSimple_67(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetText_68(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off drawing the text.  If on (default) the text is drawn.
	/// If the FileFormat is set to TeX output then a LaTeX picture is
	/// generated with the text strings.  If off text output is
	/// suppressed.
	/// </summary>
	public virtual void SetText(int _arg)
	{
		vtkGL2PSExporter_SetText_68(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetTextAsPath_69(HandleRef pThis, byte _arg);

	/// <summary>
	/// Turn on/off exporting text as path information, rather than character data.
	/// This is useful for the PDF backend, which does not properly
	/// support aligned text otherwise. Defaults to Off.
	/// </summary>
	public virtual void SetTextAsPath(bool _arg)
	{
		vtkGL2PSExporter_SetTextAsPath_69(GetCppThis(), (byte)(_arg ? 1u : 0u));
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetTitle_70(HandleRef pThis, string _arg);

	/// <summary>
	/// Set the title for the output, if supported. If nullptr, "VTK GL2PS Export" is
	/// used.
	/// </summary>
	public virtual void SetTitle(string _arg)
	{
		vtkGL2PSExporter_SetTitle_70(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SetWrite3DPropsAsRasterImage_71(HandleRef pThis, int _arg);

	/// <summary>
	/// Turn on/off writing 3D props as raster images.  2D props are
	/// rendered using vector graphics primitives.  If you have hi-res
	/// actors and are using transparency you probably need to turn this
	/// on.  Defaults to Off.
	/// This option has no effect when the OpenGL2 backend is in use, as all
	/// 3D props (excluding vtkTextActor3D) are rasterized into the background.
	/// </summary>
	public virtual void SetWrite3DPropsAsRasterImage(int _arg)
	{
		vtkGL2PSExporter_SetWrite3DPropsAsRasterImage_71(GetCppThis(), _arg);
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SilentOff_72(HandleRef pThis);

	/// <summary>
	/// Turn on/off GL2PS messages sent to stderr (GL2PS_SILENT).  When
	/// enabled GL2PS messages are suppressed.  Defaults to off.
	/// </summary>
	public virtual void SilentOff()
	{
		vtkGL2PSExporter_SilentOff_72(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SilentOn_73(HandleRef pThis);

	/// <summary>
	/// Turn on/off GL2PS messages sent to stderr (GL2PS_SILENT).  When
	/// enabled GL2PS messages are suppressed.  Defaults to off.
	/// </summary>
	public virtual void SilentOn()
	{
		vtkGL2PSExporter_SilentOn_73(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SimpleLineOffsetOff_74(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_SIMPLE_LINE_OFFSET option.  When enabled a
	/// small offset is added in the z-buffer to all the lines in the
	/// plot.  This results in an anti-aliasing like solution.  Defaults to
	/// on.
	/// </summary>
	public virtual void SimpleLineOffsetOff()
	{
		vtkGL2PSExporter_SimpleLineOffsetOff_74(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_SimpleLineOffsetOn_75(HandleRef pThis);

	/// <summary>
	/// Turn on/off the GL2PS_SIMPLE_LINE_OFFSET option.  When enabled a
	/// small offset is added in the z-buffer to all the lines in the
	/// plot.  This results in an anti-aliasing like solution.  Defaults to
	/// on.
	/// </summary>
	public virtual void SimpleLineOffsetOn()
	{
		vtkGL2PSExporter_SimpleLineOffsetOn_75(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_TextAsPathOff_76(HandleRef pThis);

	/// <summary>
	/// Turn on/off exporting text as path information, rather than character data.
	/// This is useful for the PDF backend, which does not properly
	/// support aligned text otherwise. Defaults to Off.
	/// </summary>
	public virtual void TextAsPathOff()
	{
		vtkGL2PSExporter_TextAsPathOff_76(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_TextAsPathOn_77(HandleRef pThis);

	/// <summary>
	/// Turn on/off exporting text as path information, rather than character data.
	/// This is useful for the PDF backend, which does not properly
	/// support aligned text otherwise. Defaults to Off.
	/// </summary>
	public virtual void TextAsPathOn()
	{
		vtkGL2PSExporter_TextAsPathOn_77(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_TextOff_78(HandleRef pThis);

	/// <summary>
	/// Turn on/off drawing the text.  If on (default) the text is drawn.
	/// If the FileFormat is set to TeX output then a LaTeX picture is
	/// generated with the text strings.  If off text output is
	/// suppressed.
	/// </summary>
	public virtual void TextOff()
	{
		vtkGL2PSExporter_TextOff_78(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_TextOn_79(HandleRef pThis);

	/// <summary>
	/// Turn on/off drawing the text.  If on (default) the text is drawn.
	/// If the FileFormat is set to TeX output then a LaTeX picture is
	/// generated with the text strings.  If off text output is
	/// suppressed.
	/// </summary>
	public virtual void TextOn()
	{
		vtkGL2PSExporter_TextOn_79(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_UsePainterSettings_80(HandleRef pThis);

	/// <summary>
	/// Configure the exporter to expect a painter-ordered 2D rendering, that is,
	/// a rendering at a fixed depth where primitives are drawn from the bottom up.
	/// This disables sorting, which will break the painter ordering, and turns off
	/// the simple line offset, which can cause line primitives to be drawn on top
	/// of all other geometry.
	/// </summary>
	public void UsePainterSettings()
	{
		vtkGL2PSExporter_UsePainterSettings_80(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_Write3DPropsAsRasterImageOff_81(HandleRef pThis);

	/// <summary>
	/// Turn on/off writing 3D props as raster images.  2D props are
	/// rendered using vector graphics primitives.  If you have hi-res
	/// actors and are using transparency you probably need to turn this
	/// on.  Defaults to Off.
	/// This option has no effect when the OpenGL2 backend is in use, as all
	/// 3D props (excluding vtkTextActor3D) are rasterized into the background.
	/// </summary>
	public virtual void Write3DPropsAsRasterImageOff()
	{
		vtkGL2PSExporter_Write3DPropsAsRasterImageOff_81(GetCppThis());
	}

	[DllImport("Kitware.VTK.IOExportGL2PS.Unmanaged.dll", CallingConvention = CallingConvention.Cdecl)]
	internal static extern void vtkGL2PSExporter_Write3DPropsAsRasterImageOn_82(HandleRef pThis);

	/// <summary>
	/// Turn on/off writing 3D props as raster images.  2D props are
	/// rendered using vector graphics primitives.  If you have hi-res
	/// actors and are using transparency you probably need to turn this
	/// on.  Defaults to Off.
	/// This option has no effect when the OpenGL2 backend is in use, as all
	/// 3D props (excluding vtkTextActor3D) are rasterized into the background.
	/// </summary>
	public virtual void Write3DPropsAsRasterImageOn()
	{
		vtkGL2PSExporter_Write3DPropsAsRasterImageOn_82(GetCppThis());
	}
}
